package com.czm.test;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.TreeSet;

/**
 * @author CZM
 * @date 2022 06 22 22:51
 */
public class Day05 {
    public static void main(String[] args){
        // test053();
        // test053_2();
        // test045();
        // test045_2();
        // TreeSet<Integer> intSet = new TreeSet<>();
        // intSet.add(10);
        // intSet.add(3);
        // intSet.add(9);
        // for (Integer tree : intSet) {
        //     System.out.println(tree);
        // }

        test044();
    }

    /**
     * 停车场有一横排车位0代表没有停车,1代表有车.
     至少停了一辆车在车位上,也至少有一个空位没有停车.
     为防止刮蹭,需为停车人找到一个车位
     使得停车人的车最近的车辆的距离是最大的
     返回此时的最大距离

     输入描述:
     1. 一个用半角逗号分割的停车标识字符串,停车标识为0或1,
     0为空位,1为已停车
     2. 停车位最多有100个

     输出描述
     1. 输出一个整数记录最大距离

     示例一:
     输入
     1,0,0,0,0,1,0,0,1,0,1

     输出
     2

     说明
     当车停在第三个位置上时,离其最近的车距离为2(1~3)
     当车停在第四个位置上时,离其最近的车距离为2(4~6)
     其他位置距离为1
     因此最大距离为2
     */
    //
    public static void test053(){
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        String[] split = line.split(",");
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < split.length; i++) {
            int num = Integer.parseInt(split[i]);
            if (1 == num) {
                list.add(i);
            }
        }
        // 第一辆车与停车场头的距离
        int startLen = list.get(0);
        // 最后一辆车与停车场尾的距离
        int endLen = split.length - 1 - list.get(list.size() - 1);
        int res = 0;
        for (int i = 0; i < list.size() - 1; i++) {
            // 停车后与左右车的最小距离
            int len = (list.get(i + 1) - list.get(i)) / 2;
            res = Math.max(res, len);
        }
        // 最大距离
        System.out.println(Math.max(res,Math.max(startLen, endLen)));
    }
    public static void test053_2(){
        Scanner in = new Scanner(System.in);
        String line = in.nextLine()
                .replaceAll(",", "");
        char[] sites = line.toCharArray();
        in.close();

        int max = 0;

        for (int i = 0; i < sites.length; i++) {
            char cur_site = sites[i];
            if (cur_site == '0') {
                int pre = line.indexOf('1', i);
                int suf = line.lastIndexOf('1', i);
                if (pre == -1) pre = 100;
                if (suf == -1) suf = line.length() - 1;
                int min = Math.min(pre - i, i - suf);
                if (min > max) max = min;
            }
        }

        System.out.println(max);
    }

    /**
     * 给定一个正整数数组
     检查数组中是否存在满足规则的数组组合
     规则：
     A=B+2C
     输入描述
     第一行输出数组的元素个数
     接下来一行输出所有数组元素  用空格隔开
     输出描述
     如果存在满足要求的数
     在同一行里依次输出 规则里 A/B/C的取值 用空格隔开
     如果不存在输出0

     示例1：
     输入
     4
     2 7 3 0
     输出
     7 3 2
     说明：
     7=3+2*2
     示例2：
     输入
     3
     1 1 1
     输出
     0
     说明找不到满足条件的组合

     备注：
     数组长度在3~100之间
     数组成员为0~65535
     数组成员可以重复
     但每个成员只能在结果算式中使用一次
     如 数组成员为 [0,0,1,5]
     0出现两次允许，但结果0=0+2*0不允许  因为算式中使用了3个0

     用例保证每组数字里最多只有一组符合要求的解
     */
    public static void test045(){
        Scanner sc = new Scanner(System.in);
        int len = Integer.parseInt(sc.nextLine());
        String line = sc.nextLine();
        String[] split = line.split(" ");
        // 三重循环，虽然效率低，但是简单
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len; j++) {
                for (int k = 0; k < len; k++) {
                    int a = Integer.parseInt(split[i]);
                    int b = Integer.parseInt(split[j]);
                    int c = Integer.parseInt(split[k]);
                    if (a == b + 2*c && a != b && b != c && a != c) {
                        System.out.println(a + " " + b + " " + c);
                        return;
                    }
                }
            }
        }
        System.out.println(0);
    }
    public static void test045_2(){
        Scanner in = new Scanner(System.in);
        int num = Integer.parseInt(in.nextLine());
        String[] nums = in.nextLine().split(" ");
        in.close();

        // TreeSet去重 且会按照大小升序排序,q
        TreeSet<Integer> intSet = new TreeSet<>();
        for (String s : nums) {
            intSet.add(Integer.parseInt(s));
        }

        ArrayList<Integer> list = new ArrayList<>(intSet);

        String res = "0";


        for (int a = list.size() - 1; a >= 0; a--) {
            for (int b = 0; b < a; b++) {
                for (int c = 0; c < a; c++) {
                    Integer A = list.get(a);
                    Integer B = list.get(b);
                    Integer C = list.get(c);
                    if (A == B + 2 * C && B != C) {
                        res = A + " " + B + " " + C;
                    }
                }
            }
        }

        System.out.println(res);
    }

    /**
     * 有N个正整数组成的一个序列
     给定一个整数sum
     求长度最长的的连续子序列使他们的和等于sum
     返回次子序列的长度
     如果没有满足要求的序列 返回-1
     案例1：
     输入
     1,2,3,4,2
     6
     输出
     3
     解析：1,2,3和4,2两个序列均能满足要求
     所以最长的连续序列为1,2,3 因此结果为3

     示例2：
     输入
     1,2,3,4,2
     20
     输出
     -1
     解释：没有满足要求的子序列，返回-1

     备注： 输入序列仅由数字和英文逗号构成
     数字之间采用英文逗号分割
     序列长度   1<=N<=200
     输入序列不考虑异常情况
     由题目保证输入序列满足要求
     */
    public static void test044(){
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        int num = Integer.parseInt(sc.nextLine());
        String[] split = line.split(",");
        int count = -1;
        for (int i = 0; i < split.length; i++) {
            int sum = 0;
            int j = i;
            while (j < split.length) {
                sum += Integer.parseInt(split[j]);
                if (sum < num) {
                    j++;
                } else if (sum == num) {
                    count = Math.max(count, j - i + 1);
                } else {
                    break;
                }
            }
        }
        System.out.println(count);
    }
}
